home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / ddx / Xsun / sunKbd.diffs < prev    next >
Encoding:
Text File  |  1991-11-18  |  29.7 KB  |  1,081 lines
  1. *** /tmp/,RCSt1921911    Sun Nov 17 16:15:34 1991
  2. --- sunKbd.c    Wed Jul 11 13:47:12 1990
  3. ***************
  4. *** 47,82 ****
  5.   #endif
  6.   
  7.   
  8.   #define NEED_EVENTS
  9.   #include "sun.h"
  10. ! #include <stdio.h>
  11. ! #include "Xproto.h"
  12.   #include "keysym.h"
  13. ! #include "inputstr.h"
  14.   
  15.   typedef struct {
  16.       int              trans;              /* Original translation form */
  17.   } SunKbPrivRec, *SunKbPrivPtr;
  18.   
  19. - extern CARD8 *sunModMap[];
  20. - extern KeySymsRec sunKeySyms[];
  21. - 
  22.   extern void    ProcessInputEvents();
  23.   extern void    miPointerPosition();
  24.   
  25.   static void       sunBell();
  26.   static void       sunKbdCtrl();
  27. ! static Firm_event *sunKbdGetEvents();
  28.   static void       sunKbdProcessEvent();
  29.   static void       sunKbdDoneEvents();
  30. - int            autoRepeatKeyDown = 0;
  31. - int            autoRepeatDebug = 0;
  32. - int            autoRepeatReady;
  33. - long            autoRepeatInitiate = 1000 * AUTOREPEAT_INITIATE;
  34. - long            autoRepeatDelay = 1000 * AUTOREPEAT_DELAY;
  35. - static int      autoRepeatFirst;
  36. - struct timeval    autoRepeatLastKeyDownTv;
  37. - struct timeval    autoRepeatDeltaTv;
  38.   static KeybdCtrl  sysKbCtrl;
  39.   
  40.   static SunKbPrivRec    sunKbPriv;  
  41. --- 47,98 ----
  42.   #endif
  43.   
  44.   
  45. + #define Time SpriteTime
  46. + #include <fs.h>
  47. + #undef Time
  48.   #define NEED_EVENTS
  49.   #include "sun.h"
  50. ! #include <bit.h>
  51. ! #include <errno.h>
  52. ! #include <fcntl.h>
  53. ! #include <sys/file.h>
  54. ! #include <sys/time.h>
  55.   #include "keysym.h"
  56. ! #include "keymap.h"
  57.   
  58. + #define AUTO_GENERATED    0x10000
  59. + #define MIN_KEYCODE    8       /* Keycode below which we may not transmit */
  60. + #define ALL_KEYS_UP    127    /* all keys are up now */
  61. + 
  62. + /*
  63. +  * Auto-repeat stuff.
  64. +  */
  65. + static enum {
  66. +     REPEAT_LONG,        /* Start repeat with long timeout */
  67. +     REPEAT_SHORT,        /* Start repeat with short timeout */
  68. +     REPEAT_TIMEOUT,        /* In the middle of a timeout */
  69. +     REPEAT_PENDING,        /* Repeat should be taken next */
  70. +     REPEAT_NONE              /* No repeat should happen */
  71. + } repeatPhase = REPEAT_NONE;
  72. + static Mouse_Event    repeatEvent;    /* Event that will be repeated */
  73. + static struct timeval     repeatTimeout;    /* Timeout to use for repeating */
  74. + static unsigned int    repeatDelta;    /* Timeout length (ms) */
  75. + /* The following two are set in sunIo.c */
  76. + unsigned int        repeatLong=300;    /* Ms delay to begin repeat */
  77. + unsigned int        repeatShort=10;    /* Ms delay to begin repeat */
  78. + 
  79.   typedef struct {
  80.       int              trans;              /* Original translation form */
  81.   } SunKbPrivRec, *SunKbPrivPtr;
  82.   
  83.   extern void    ProcessInputEvents();
  84.   extern void    miPointerPosition();
  85.   
  86.   static void       sunBell();
  87.   static void       sunKbdCtrl();
  88. ! static Mouse_Event *sunKbdGetEvents();
  89.   static void       sunKbdProcessEvent();
  90.   static void       sunKbdDoneEvents();
  91.   static KeybdCtrl  sysKbCtrl;
  92.   
  93.   static SunKbPrivRec    sunKbPriv;  
  94. ***************
  95. *** 88,94 ****
  96.       sunKbdDoneEvents,        /* Function called when all events */
  97.                   /* have been handled. */
  98.       (pointer)&sunKbPriv,    /* Private to keyboard device */
  99. -     (Bool)0,            /* Mapped queue */
  100.       0,                /* offset for device keycodes */
  101.       &sysKbCtrl,            /* Initial full duration = .25 sec. */
  102.   };
  103. --- 104,109 ----
  104. ***************
  105. *** 119,128 ****
  106.   {
  107.       KbPrivPtr      pPriv;
  108.       register int  kbdFd;
  109. - #ifdef    SUN_WINDOWS
  110. - #define    TR_UNDEFINED (TR_NONE-1)
  111. -     static int      deviceOffKbdState = TR_UNDEFINED;
  112. - #endif    SUN_WINDOWS
  113.   
  114.       switch (what) {
  115.       case DEVICE_INIT:
  116. --- 134,139 ----
  117. ***************
  118. *** 134,191 ****
  119.           /*
  120.            * First open and find the current state of the keyboard.
  121.            */
  122. ! /*
  123. !  * The Sun 386i has system include files that preclude this pre SunOS 4.1
  124. !  * test for the presence of a type 4 keyboard however it really doesn't
  125. !  * matter since no 386i has ever been shipped with a type 3 keyboard.
  126. !  */
  127. ! #ifndef i386
  128. ! #define TYPE4KEYBOARDOVERRIDE
  129. ! #endif
  130. !         if (sysKbPriv.fd >= 0) {
  131. !         kbdFd = sysKbPriv.fd;
  132. !         } else {
  133. !         kbdFd = open ("/dev/kbd", O_RDWR, 0);
  134. !         if (kbdFd < 0) {
  135. !             Error ("Opening /dev/kbd");
  136.               return (!Success);
  137.           }
  138. -         sysKbPriv.fd = kbdFd;
  139. -         (void) ioctl (kbdFd, KIOCTYPE, &sysKbPriv.type);
  140. -         (void) ioctl (kbdFd, KIOCGTRANS, &sunKbPriv.trans);
  141. - #ifdef TYPE4KEYBOARDOVERRIDE
  142. -                 /*
  143. -                  * Magic. Look for a key which is non-existent on a real type
  144. -                  * 3 keyboard but does exist on a type 4 keyboard.
  145. -                  */
  146. -                 if (sysKbPriv.type == KB_SUN3) {
  147. -                     struct kiockey key;
  148. - 
  149. -                     key.kio_tablemask = 0;
  150. -                     key.kio_station = 118;
  151. -                     if (ioctl(kbdFd, KIOCGETKEY, &key)) {
  152. -                         perror( "ioctl KIOCGETKEY" );
  153. -             FatalError("Can't KIOCGETKEY on fd %d\n", kbdFd);
  154. -                     }
  155. -                     if (key.kio_entry != HOLE)
  156. -                         sysKbPriv.type = KB_SUN4;
  157. -                 }
  158. - #endif
  159. - 
  160. -         if (sysKbPriv.type < 0 || sysKbPriv.type > KB_SUN4
  161. -             || sunKeySyms[sysKbPriv.type].map == NULL)
  162. -             FatalError("Unsupported keyboard type %d\n", 
  163. -             sysKbPriv.type);
  164. -         if (sunUseSunWindows()) {
  165. -             (void) close( kbdFd );
  166. -             sysKbPriv.fd = -1;
  167. -         } else {
  168. -             if (fcntl (kbdFd, F_SETFL, (FNDELAY|FASYNC)) < 0
  169. -             || fcntl(kbdFd, F_SETOWN, getpid()) < 0) {
  170. -             perror("sunKbdProc");
  171. -             FatalError("Can't set up kbd on fd %d\n", kbdFd);
  172. -             }
  173. -         }
  174.           }
  175.   
  176.           /*
  177. --- 145,160 ----
  178.           /*
  179.            * First open and find the current state of the keyboard.
  180.            */
  181. !         if (sysKbPriv.fd < 0) {
  182. !             ReturnStatus status;
  183. ! 
  184. !         status = Fs_Open("/dev/mouse",
  185. !             FS_NON_BLOCKING|FS_READ|FS_WRITE, 0, &sysKbPriv.fd);
  186. !             if (status != 0) {
  187. !             errno = Compat_MapCode(status);
  188. !             Error ("Opening /dev/mouse");
  189.               return (!Success);
  190.           }
  191.           }
  192.   
  193.           /*
  194. ***************
  195. *** 201,307 ****
  196.           /*
  197.            * ensure that the keycodes on the wire are >= MIN_KEYCODE
  198.            */
  199. !         if (sunKeySyms[sysKbPriv.type].minKeyCode < MIN_KEYCODE) {
  200. !         int offset = MIN_KEYCODE -sunKeySyms[sysKbPriv.type].minKeyCode;
  201.   
  202. !         sunKeySyms[sysKbPriv.type].minKeyCode += offset;
  203. !         sunKeySyms[sysKbPriv.type].maxKeyCode += offset;
  204. !         sysKbPriv.offset = offset;
  205. !         }
  206. !         InitKeyboardDeviceStruct(
  207. !             pKeyboard,
  208. !             &(sunKeySyms[sysKbPriv.type]),
  209. !             (sunModMap[sysKbPriv.type]),
  210. !             sunBell,
  211. !             sunKbdCtrl);
  212.           break;
  213.   
  214.       case DEVICE_ON:
  215. !         if (sunUseSunWindows()) {
  216. ! #ifdef SUN_WINDOWS
  217. !         if (! sunSetUpKbdSunWin(windowFd, TRUE)) {
  218. !             FatalError("Can't set up keyboard\n");
  219. !         }
  220. !         /*
  221. !          * Don't tamper with keyboard translation here
  222. !          * unless this is a server reset.  If server
  223. !          * is reset then set translation to that saved
  224. !          * when DEVICE_CLOSE was executed.
  225. !          * Translation is set/reset upon receipt of
  226. !          * KBD_USE/KBD_DONE input events (sunIo.c)
  227. !          */
  228. !         if (deviceOffKbdState != TR_UNDEFINED) {
  229. !             if (sunChangeKbdTranslation(pKeyboard,
  230. !                 deviceOffKbdState == TR_UNTRANS_EVENT) < 0) {
  231. !             FatalError("Can't set (SW) keyboard translation\n");
  232. !             }
  233. !         }
  234. !         AddEnabledDevice(windowFd);
  235. ! #endif SUN_WINDOWS
  236. !         }
  237. !         else {
  238. !         pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  239. !         kbdFd = pPriv->fd;
  240. ! 
  241. !             /*
  242. !              * Set the keyboard into "direct" mode and turn on
  243. !              * event translation.
  244. !              */
  245. !         if (sunChangeKbdTranslation(pKeyboard,TRUE) < 0) {
  246. !             FatalError("Can't set keyboard translation\n");
  247. !         }
  248. ! 
  249. !         AddEnabledDevice(kbdFd);
  250. !         }
  251.           pKeyboard->on = TRUE;
  252.           break;
  253.   
  254.       case DEVICE_CLOSE:
  255.       case DEVICE_OFF:
  256. !         if (sunUseSunWindows()) {
  257. ! #ifdef SUN_WINDOWS
  258. !         /*
  259. !          * Save current translation state in case of server
  260. !          * reset.  Used above when DEVICE_ON is executed.
  261. !          */
  262. !         if ((kbdFd = open("/dev/kbd", O_RDONLY, 0)) < 0) {
  263. !             Error("DEVICE_OFF: Can't open kbd\n");
  264. !             goto badkbd;
  265. !         }
  266. !         if (ioctl(kbdFd, KIOCGTRANS, &deviceOffKbdState) < 0) {
  267. !             Error("Can't save keyboard state\n");
  268. !         }
  269. !         (void) close(kbdFd);
  270. ! 
  271. ! badkbd:
  272. !         if (! sunSetUpKbdSunWin(windowFd, FALSE)) {
  273. !             FatalError("Can't close keyboard\n");
  274. !         }
  275. ! 
  276. !         /*
  277. !          * Restore SunWindows translation.
  278. !          */
  279. !         if (sunChangeKbdTranslation(pKeyboard,FALSE) < 0) {
  280. !             FatalError("Can't reset keyboard translation\n");
  281. !         }
  282. ! 
  283. !         RemoveEnabledDevice(windowFd);
  284. ! #endif SUN_WINDOWS
  285. !         }
  286. !         else {
  287. !         pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  288. !         kbdFd = pPriv->fd;
  289. ! 
  290. !             /*
  291. !              * Restore original keyboard directness and translation.
  292. !              */
  293. !         if (sunChangeKbdTranslation(pKeyboard,FALSE) < 0) {
  294. !             FatalError("Can't reset keyboard translation\n");
  295. !         }
  296. ! 
  297. !         RemoveEnabledDevice(kbdFd);
  298. !         }
  299.           pKeyboard->on = FALSE;
  300.           break;
  301.       }
  302.       return (Success);
  303. --- 170,202 ----
  304.           /*
  305.            * ensure that the keycodes on the wire are >= MIN_KEYCODE
  306.            */
  307. !          if (sunMapDesc.minKeyCode < MIN_KEYCODE) {
  308. !          int    offset;
  309.   
  310. !          offset = MIN_KEYCODE - sunMapDesc.minKeyCode;
  311. !          sunMapDesc.minKeyCode += offset;
  312. !          sunMapDesc.maxKeyCode += offset;
  313. !          sysKbPriv.offset = offset;
  314. !          }
  315. !         InitKeyboardDeviceStruct(pKeyboard, &sunMapDesc, sunModMap,
  316. !                      sunBell, sunKbdCtrl);
  317.           break;
  318.   
  319.       case DEVICE_ON:
  320. !         pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  321. !         kbdFd = pPriv->fd;
  322. !         AddEnabledDevice(kbdFd);
  323.           pKeyboard->on = TRUE;
  324. +         repeatPhase = REPEAT_NONE;
  325.           break;
  326.   
  327.       case DEVICE_CLOSE:
  328.       case DEVICE_OFF:
  329. !         pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  330. !         kbdFd = pPriv->fd;
  331. !         RemoveEnabledDevice(kbdFd);
  332.           pKeyboard->on = FALSE;
  333. +         repeatPhase = REPEAT_NONE;
  334.           break;
  335.       }
  336.       return (Success);
  337. ***************
  338. *** 326,371 ****
  339.       int              loudness;        /* Percentage of full volume */
  340.       DevicePtr      pKeyboard;        /* Keyboard to ring */
  341.   {
  342. !     KbPrivPtr      pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
  343. !     int            kbdCmd;           /* Command to give keyboard */
  344. !     int           kbdOpenedHere; 
  345. !  
  346.       if (loudness == 0) {
  347. !      return;
  348.       }
  349.   
  350. !     kbdOpenedHere = ( pPriv->fd < 0 );
  351. !     if ( kbdOpenedHere ) {
  352. !     pPriv->fd = open("/dev/kbd", O_RDWR, 0);
  353. !     if (pPriv->fd < 0) {
  354. !         ErrorF("sunBell: can't open keyboard");
  355. !         return;
  356. !     }
  357. !     }    
  358. !  
  359. !     kbdCmd = KBD_CMD_BELL;
  360. !     if (ioctl (pPriv->fd, KIOCCMD, &kbdCmd) < 0) {
  361. !      ErrorF ("Failed to activate bell");
  362. !     goto bad;
  363. !     }
  364. !  
  365. !     /*
  366. !      * Leave the bell on for a while == duration (ms) proportional to
  367. !      * loudness desired with a 10 thrown in to convert from ms to usecs.
  368. !      */
  369. !     usleep (pPriv->ctrl->bell_duration * 1000);
  370. !  
  371. !     kbdCmd = KBD_CMD_NOBELL;
  372. !     if (ioctl (pPriv->fd, KIOCCMD, &kbdCmd) < 0) {
  373. !     ErrorF ("Failed to deactivate bell");
  374. !     goto bad;
  375. !     }
  376. ! 
  377. ! bad:
  378. !     if ( kbdOpenedHere ) {
  379. !     (void) close(pPriv->fd);
  380. !     pPriv->fd = -1;
  381. !     }
  382.   }
  383.   
  384.   /*-
  385. --- 221,247 ----
  386.       int              loudness;        /* Percentage of full volume */
  387.       DevicePtr      pKeyboard;        /* Keyboard to ring */
  388.   {
  389. !     KbPrivPtr        pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  390. !     char        kbdCmd;
  391. !     struct timeval    sleepTime;
  392. ! 
  393.       if (loudness == 0) {
  394. !     return;
  395.       }
  396.   
  397. !     kbdCmd = KBD_BELL_ON;
  398. !     (void) write(pPriv->fd, &kbdCmd, 1);
  399. ! 
  400. !     sleepTime.tv_usec = pPriv->ctrl->bell_duration * 1000;
  401. !     sleepTime.tv_sec = 0;
  402. !     while (sleepTime.tv_usec >= 1000000) {
  403. !     sleepTime.tv_sec += 1;
  404. !     sleepTime.tv_usec -= 1000000;
  405. !     }
  406. !     (void) select(0, (int *) 0, (int *) 0, (int *) 0, &sleepTime);
  407. ! 
  408. !     kbdCmd = KBD_BELL_OFF;
  409. !     (void) write(pPriv->fd, &kbdCmd, 1);
  410.   }
  411.   
  412.   /*-
  413. ***************
  414. *** 386,415 ****
  415.       DevicePtr      pKeyboard;        /* Keyboard to alter */
  416.       KeybdCtrl     *ctrl;
  417.   {
  418. !     KbPrivPtr      pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
  419. !     int           kbdClickCmd = ctrl->click ? KBD_CMD_CLICK : KBD_CMD_NOCLICK;
  420. !     int           kbdOpenedHere; 
  421.   
  422. !     kbdOpenedHere = ( pPriv->fd < 0 );
  423. !     if ( kbdOpenedHere ) {
  424. !     pPriv->fd = open("/dev/kbd", O_WRONLY, 0);
  425. !     if (pPriv->fd < 0) {
  426. !         ErrorF("sunKbdCtrl: can't open keyboard");
  427. !         return;
  428. !     }
  429. !     }
  430.   
  431. !     if (ioctl (pPriv->fd, KIOCCMD, &kbdClickCmd) < 0) {
  432. !      ErrorF("Failed to set keyclick");
  433. !     goto bad;
  434.       }
  435. !  
  436. !     *pPriv->ctrl = *ctrl;
  437. ! 
  438. ! bad:
  439. !     if ( kbdOpenedHere ) {
  440. !     (void) close(pPriv->fd);
  441. !     pPriv->fd = -1;
  442.       }
  443.   }
  444.   
  445. --- 262,283 ----
  446.       DevicePtr      pKeyboard;        /* Keyboard to alter */
  447.       KeybdCtrl     *ctrl;
  448.   {
  449. !     KbPrivPtr      pPriv;
  450. !     char      kbCmd;
  451.   
  452. !     pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  453.   
  454. !     pPriv->ctrl = ctrl;
  455. !     if (ctrl->click) {
  456. !     kbCmd = KBD_CLICK_ON;
  457. !     } else {
  458. !     kbCmd = KBD_CLICK_OFF;
  459.       }
  460. ! 
  461. !     (void) write(pPriv->fd, &kbCmd, 1);
  462. ! 
  463. !     if (!ctrl->autoRepeat) {
  464. !     repeatPhase = REPEAT_NONE;
  465.       }
  466.   }
  467.   
  468. ***************
  469. *** 432,470 ****
  470.    *    None.
  471.    *-----------------------------------------------------------------------
  472.    */
  473. ! static Firm_event *
  474. ! sunKbdGetEvents (pKeyboard, pNumEvents, pAgain)
  475.       DevicePtr      pKeyboard;        /* Keyboard to read */
  476.       int              *pNumEvents;        /* Place to return number of events */
  477. -     Bool      *pAgain;        /* whether more might be available */
  478.   {
  479.       int              nBytes;        /* number of bytes of events available. */
  480.       KbPrivPtr      pPriv;
  481. !     static Firm_event    evBuf[MAXEVENTS];   /* Buffer for Firm_events */
  482.   
  483. !     pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
  484. !     nBytes = read (pPriv->fd, evBuf, sizeof(evBuf));
  485.   
  486. !     if (nBytes < 0) {
  487. !     if (errno == EWOULDBLOCK) {
  488. !         *pNumEvents = 0;
  489. !         *pAgain = FALSE;
  490. !     } else {
  491. !         Error ("Reading keyboard");
  492. !         FatalError ("Could not read the keyboard");
  493. !     }
  494. !     } else {
  495. !     *pNumEvents = nBytes / sizeof (Firm_event);
  496. !     *pAgain = (nBytes == sizeof (evBuf));
  497. !     }
  498.   
  499. !     if (autoRepeatKeyDown && autoRepeatReady &&
  500. !          pPriv->ctrl->autoRepeat == AutoRepeatModeOn && *pNumEvents == 0) {
  501. !     *pNumEvents = 1;            /* Fake the event */
  502. !     evBuf[0].id = AUTOREPEAT_EVENTID;    /* Flags autoRepeat event */
  503. !     if (autoRepeatDebug)
  504. !         ErrorF("sunKbdGetEvents: autoRepeatKeyDown = %d event\n",
  505. !                 autoRepeatKeyDown);
  506.       }
  507.   
  508.       return (evBuf);
  509. --- 300,344 ----
  510.    *    None.
  511.    *-----------------------------------------------------------------------
  512.    */
  513. ! static Mouse_Event *
  514. ! sunKbdGetEvents (pKeyboard, pNumEvents)
  515.       DevicePtr      pKeyboard;        /* Keyboard to read */
  516.       int              *pNumEvents;        /* Place to return number of events */
  517.   {
  518.       int              nBytes;        /* number of bytes of events available. */
  519.       KbPrivPtr      pPriv;
  520. !     static Mouse_Event    evBuf[MAXEVENTS];   /* Buffer for Firm_events */
  521.   
  522. !     if (repeatPhase == REPEAT_PENDING) {
  523. !     /*
  524. !      * This will only have been set if no streams were really ready, thus
  525. !      * there are no events to read from /dev/mouse.
  526. !      */
  527. !     repeatEvent.flags |= KEY_UP;
  528. !     repeatEvent.time += repeatDelta / 2;
  529. !     evBuf[0] = repeatEvent;
  530.   
  531. !     repeatEvent.flags &= ~KEY_UP;
  532. !     repeatEvent.time += repeatDelta / 2;
  533. !     evBuf[1] = repeatEvent;
  534. ! 
  535. !     *pNumEvents = 2;
  536.   
  537. !     repeatPhase = REPEAT_SHORT;
  538. !     } else {
  539. !         pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
  540. !         nBytes = read (pPriv->fd, evBuf, sizeof(evBuf));
  541. !     
  542. !         if (nBytes < 0) {
  543. !         if (errno == EWOULDBLOCK) {
  544. !             *pNumEvents = 0;
  545. !         } else {
  546. !             Error ("Reading keyboard");
  547. !             FatalError ("Could not read the keyboard");
  548. !             }
  549. !         } else {
  550. !         *pNumEvents = nBytes / sizeof (Mouse_Event);
  551. !         }
  552.       }
  553.   
  554.       return (evBuf);
  555. ***************
  556. *** 490,579 ****
  557.    *-----------------------------------------------------------------------
  558.    */
  559.   static void
  560. ! sunKbdProcessEvent (pKeyboard, fe)
  561.       DevicePtr      pKeyboard;
  562. !     Firm_event      *fe;
  563.   {
  564.       xEvent        xE;
  565. !     KbPrivPtr        pPriv;
  566. !     int            delta;
  567. !     static xEvent    autoRepeatEvent;
  568. !     BYTE        key;
  569. !     CARD8        keyModifiers;
  570. ! 
  571. !     if (autoRepeatKeyDown && fe->id == AUTOREPEAT_EVENTID) {
  572. !     pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
  573. !     if (pPriv->ctrl->autoRepeat != AutoRepeatModeOn) {
  574. !         autoRepeatKeyDown = 0;
  575. !         return;
  576. !     }
  577. !     /*
  578. !      * Generate auto repeat event.    XXX one for now.
  579. !      * Update time & pointer location of saved KeyPress event.
  580. !      */
  581. !     if (autoRepeatDebug)
  582. !         ErrorF("sunKbdProcessEvent: autoRepeatKeyDown = %d\n",
  583. !             autoRepeatKeyDown);
  584.   
  585. !     delta = TVTOMILLI(autoRepeatDeltaTv);
  586. !     autoRepeatFirst = FALSE;
  587. ! 
  588. !     /*
  589. !      * Fake a key up event and a key down event
  590. !      * for the last key pressed.
  591. !      */
  592. !     autoRepeatEvent.u.keyButtonPointer.time += delta;
  593. !     miPointerPosition (screenInfo.screens[0],
  594. !                &autoRepeatEvent.u.keyButtonPointer.rootX,
  595. !                &autoRepeatEvent.u.keyButtonPointer.rootY);
  596. !     autoRepeatEvent.u.u.type = KeyRelease;
  597. !     (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard, 1);
  598. ! 
  599. !     autoRepeatEvent.u.u.type = KeyPress;
  600. !     (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard, 1);
  601. ! 
  602. !     /* Update time of last key down */
  603. !     tvplus(autoRepeatLastKeyDownTv, autoRepeatLastKeyDownTv, 
  604. !             autoRepeatDeltaTv);
  605. ! 
  606. !     return;
  607. !     }
  608.   
  609. !     key = (fe->id & 0x7F) + sysKbPriv.offset;
  610. !     keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key];
  611. !     if (autoRepeatKeyDown && (keyModifiers == 0) &&
  612. !     ((fe->value == VKEY_DOWN) || (key == autoRepeatEvent.u.u.detail))) {
  613. !     /*
  614. !      * Kill AutoRepeater on any real non-modifier key down, or auto key up
  615. !      */
  616. !     autoRepeatKeyDown = 0;
  617. !     if (autoRepeatDebug)
  618. !         ErrorF("sunKbdProcessEvent: autoRepeat off\n");
  619.       }
  620. - 
  621. -     xE.u.keyButtonPointer.time = TVTOMILLI(fe->time);
  622.       miPointerPosition (screenInfo.screens[0],
  623.                  &xE.u.keyButtonPointer.rootX,
  624.                  &xE.u.keyButtonPointer.rootY);
  625. -     xE.u.u.type = ((fe->value == VKEY_UP) ? KeyRelease : KeyPress);
  626. -     xE.u.u.detail = key;
  627. - 
  628. -     if (keyModifiers & LockMask) {
  629. -     if (xE.u.u.type == KeyRelease)
  630. -         return; /* this assumes autorepeat is not desired */
  631. -     if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down, key))
  632. -         xE.u.u.type = KeyRelease;
  633. -     }
  634. - 
  635. -     if ((xE.u.u.type == KeyPress) && (keyModifiers == 0)) {
  636. -     /* initialize new AutoRepeater event & mark AutoRepeater on */
  637. -     if (autoRepeatDebug)
  638. -             ErrorF("sunKbdProcessEvent: VKEY_DOWN\n");
  639. -     autoRepeatEvent = xE;
  640. -     autoRepeatFirst = TRUE;
  641. -     autoRepeatKeyDown++;
  642. -     autoRepeatLastKeyDownTv = fe->time;
  643. -     }
  644.   
  645.       (* pKeyboard->processInputProc) (&xE, pKeyboard, 1);
  646.   }
  647. --- 364,410 ----
  648.    *-----------------------------------------------------------------------
  649.    */
  650.   static void
  651. ! sunKbdProcessEvent (pKeyboard, ev)
  652.       DevicePtr      pKeyboard;
  653. !     Mouse_Event      *ev;
  654.   {
  655.       xEvent        xE;
  656. !     register KbPrivPtr    pPriv;
  657. !     register int      smask;
  658. !     PtrPrivPtr          ptrPriv;
  659.   
  660. !     pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  661. !     ptrPriv = (PtrPrivPtr) LookupPointerDevice()->devicePrivate;
  662.   
  663. !     xE.u.keyButtonPointer.time = ev->time;
  664. !     xE.u.u.detail = ev->key + pPriv->offset;
  665. !     if (ev->key == ALL_KEYS_UP) {
  666. !     xE.u.u.type = KeyRelease;
  667. !     repeatPhase = REPEAT_NONE;
  668. !     } else if (ev->flags & KEY_UP) {
  669. !     xE.u.u.type = KeyRelease;
  670. !     if (!(ev->flags & AUTO_GENERATED) &&
  671. !          (repeatPhase != REPEAT_NONE) &&
  672. !          (repeatEvent.key == ev->key)) {
  673. !         /*
  674. !          * Turn off repeat if we got a real up event for the key
  675. !          * being repeated
  676. !          */
  677. !         repeatPhase = REPEAT_NONE;
  678. !     }
  679. !     } else {
  680. !     xE.u.u.type = KeyPress;
  681. !     if ((repeatPhase != REPEAT_SHORT) &&
  682. !         (pPriv->ctrl->autoRepeat ||
  683. !          Bit_IsSet (xE.u.u.detail, pPriv->ctrl->autoRepeats))) {
  684. !          repeatEvent = *ev;
  685. !          repeatEvent.flags |= AUTO_GENERATED;
  686. !          repeatPhase = REPEAT_LONG;
  687. !     }
  688.       }
  689.       miPointerPosition (screenInfo.screens[0],
  690.                  &xE.u.keyButtonPointer.rootX,
  691.                  &xE.u.keyButtonPointer.rootY);
  692.   
  693.       (* pKeyboard->processInputProc) (&xE, pKeyboard, 1);
  694.   }
  695. ***************
  696. *** 598,875 ****
  697.   
  698.   /*-
  699.    *-----------------------------------------------------------------------
  700. !  * sunChangeKbdTranslation
  701. !  *    Makes operating system calls to set keyboard translation 
  702. !  *    and direction on or off.
  703.    *
  704.    * Results:
  705. !  *    -1 if failure, else 0.
  706. !  *
  707. !  * Side Effects:
  708. !  *     Changes kernel management of keyboard.
  709.    *
  710. -  *-----------------------------------------------------------------------
  711. -  */
  712. - int
  713. - sunChangeKbdTranslation(pKeyboard,makeTranslated)
  714. -     DevicePtr pKeyboard;
  715. -     Bool makeTranslated;
  716. - {   
  717. -     KbPrivPtr    pPriv;
  718. -     int     kbdFd;
  719. -     int     tmp;
  720. -     int        kbdOpenedHere;
  721. - 
  722. -     static struct timeval lastChngKbdTransTv;
  723. -     struct timeval tv;
  724. -     struct timeval lastChngKbdDeltaTv;
  725. -     int lastChngKbdDelta;
  726. - 
  727. -     /*
  728. -      * Workaround for SS1 serial driver kernel bug when KIOCTRANS ioctl()s
  729. -      * occur too closely together in time.
  730. -      */
  731. -     gettimeofday(&tv, (struct timezone *) NULL);
  732. -     tvminus(lastChngKbdDeltaTv, tv, lastChngKbdTransTv);
  733. -     lastChngKbdDelta = TVTOMILLI(lastChngKbdDeltaTv);
  734. -     if (lastChngKbdDelta < 750) {
  735. -     struct timeval wait;
  736. - 
  737. -     /*
  738. -          * We need to guarantee at least 750 milliseconds between
  739. -      * calls to KIOCTRANS. YUCK!
  740. -      */
  741. -     wait.tv_sec = 0;
  742. -     wait.tv_usec = (750L - lastChngKbdDelta) * 1000L;
  743. -         (void) select(0, (int *)0, (int *)0, (int *)0, &wait);
  744. -         gettimeofday(&tv, (struct timezone *) NULL);
  745. -     }
  746. -     lastChngKbdTransTv = tv;
  747. -     
  748. - 
  749. -     pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  750. -     kbdFd = pPriv->fd;
  751. - 
  752. -     kbdOpenedHere = ( kbdFd < 0 );
  753. -     if ( kbdOpenedHere ) {
  754. -     kbdFd = open("/dev/kbd", O_RDONLY, 0);
  755. -     if ( kbdFd < 0 ) {
  756. -         Error( "sunChangeKbdTranslation: Can't open keyboard" );
  757. -         goto bad;
  758. -     }
  759. -     }
  760. -     
  761. -     if (makeTranslated) {
  762. -         /*
  763. -          * Next set the keyboard into "direct" mode and turn on
  764. -          * event translation. If either of these fails, we can't go
  765. -          * on.
  766. -          */
  767. -     if ( ! sunUseSunWindows() ) {
  768. -         tmp = 1;
  769. -         if (ioctl (kbdFd, KIOCSDIRECT, &tmp) < 0) {
  770. -         Error ("Setting keyboard direct mode");
  771. -         goto bad;
  772. -         }
  773. -     }
  774. -     tmp = TR_UNTRANS_EVENT;
  775. -     if (ioctl (kbdFd, KIOCTRANS, &tmp) < 0) {
  776. -         ErrorF("sunChangeKbdTranslation: kbdFd=%d\n",kbdFd);
  777. -         Error ("Setting keyboard translation");
  778. -         goto bad;
  779. -     }
  780. -     }
  781. -     else {
  782. -         /*
  783. -          * Next set the keyboard into "indirect" mode and turn off
  784. -          * event translation.
  785. -          */
  786. -     if ( ! sunUseSunWindows() ) {
  787. -         tmp = 0;
  788. -         (void)ioctl (kbdFd, KIOCSDIRECT, &tmp);
  789. -     }
  790. -     tmp = ((SunKbPrivPtr)pPriv->devPrivate)->trans;
  791. -     (void)ioctl (kbdFd, KIOCTRANS, &tmp);
  792. -     }
  793. - 
  794. -     if ( kbdOpenedHere )
  795. -     (void) close( kbdFd );
  796. -     return(0);
  797. - 
  798. - bad:
  799. -     if ( kbdOpenedHere && kbdFd >= 0 )
  800. -     (void) close( kbdFd );
  801. -     return(-1);
  802. - }
  803. - 
  804. - #ifdef SUN_WINDOWS
  805. - 
  806. - /*-
  807. -  *-----------------------------------------------------------------------
  808. -  * sunSetUpKbdSunWin
  809. -  *    Change which events the kernel will pass through as keyboard
  810. -  *     events.
  811. -  *
  812. -  *    Does NOT affect keyboard translation.
  813. -  *
  814. -  * Results:
  815. -  *    Inputevent mask modified.
  816. -  *
  817.    * Side Effects:
  818.    *
  819.    *-----------------------------------------------------------------------
  820.    */
  821. - 
  822.   Bool
  823. ! sunSetUpKbdSunWin(windowFd, onoff)
  824. !     int windowFd;
  825. !     Bool onoff;
  826.   {
  827. -     struct inputmask inputMask;
  828. -     static struct inputmask oldInputMask;
  829. - 
  830. -     if (onoff) {
  831. -         register int i;
  832. - 
  833. -     win_get_kbd_mask(windowFd, &oldInputMask);
  834. -     input_imnull(&inputMask);
  835. -     inputMask.im_flags |= 
  836. -         IM_ASCII | IM_NEGASCII | 
  837. -         IM_META | IM_NEGMETA | 
  838. -         IM_NEGEVENT | IM_INTRANSIT;
  839. -     win_setinputcodebit(&inputMask, KBD_USE);
  840. -     win_setinputcodebit(&inputMask, KBD_DONE);
  841. -     win_setinputcodebit(&inputMask, SHIFT_CAPSLOCK);
  842. -     win_setinputcodebit(&inputMask, SHIFT_LOCK);
  843. -     win_setinputcodebit(&inputMask, SHIFT_LEFT);
  844. -     win_setinputcodebit(&inputMask, SHIFT_RIGHT);
  845. -     win_setinputcodebit(&inputMask, SHIFT_LEFTCTRL);
  846. -     win_setinputcodebit(&inputMask, SHIFT_RIGHTCTRL);
  847. -     win_setinputcodebit(&inputMask, SHIFT_META);
  848. -     win_setinputcodebit(&inputMask, WIN_STOP);
  849. - 
  850. -         for (i=KEY_LEFTFIRST; i<=KEY_LEFTLAST; i++) {
  851. -             win_setinputcodebit(&inputMask, i);
  852. -         }
  853. -         for (i=KEY_TOPFIRST; i<=KEY_TOPLAST; i++) {
  854. -             win_setinputcodebit(&inputMask, i);
  855. -         }
  856. -         for (i=KEY_RIGHTFIRST; i<=KEY_RIGHTLAST; i++) {
  857. -             win_setinputcodebit(&inputMask, i);
  858. -         }
  859. - 
  860. -     win_set_kbd_mask(windowFd, &inputMask);
  861. -     }
  862. -     else {
  863. -     win_set_kbd_mask(windowFd, &oldInputMask);
  864. -     }
  865.       return (TRUE);
  866.   }
  867.   
  868. ! #endif SUN_WINDOWS
  869. ! 
  870. ! 
  871. ! #ifdef SUN_WINDOWS
  872.   
  873.   /*-
  874.    *-----------------------------------------------------------------------
  875. !  * sunKbdProcessEventSunWin
  876. !  *    Process sunwindows event destined for the keyboard.
  877. !  *      Rather than replicate the logic (and therefore replicate
  878. !  *     bug fixes, etc), this code counterfeits a vuid 
  879. !  *    Firm_event and then uses the non-sunwindows code.
  880. !  *     
  881.    * Results:
  882.    *
  883.    * Side Effects:
  884.    *
  885.    *-----------------------------------------------------------------------
  886.    */
  887. - 
  888. - void
  889. - sunKbdProcessEventSunWin(pKeyboard,se)
  890. -     DeviceRec *pKeyboard;
  891. -     register struct inputevent *se;
  892. - {   
  893. -     Firm_event    fe;
  894. - 
  895. -     fe.time = event_time(se);
  896. -     fe.id = event_id(se);
  897. -     fe.value = (event_is_up(se) ? VKEY_UP : VKEY_DOWN);
  898. - 
  899. -     sunKbdProcessEvent (pKeyboard, &fe);
  900. - }
  901. - #endif SUN_WINDOWS
  902. - 
  903. - /*ARGSUSED*/
  904. - Bool
  905. - LegalModifier(key)
  906. - {
  907. -     return (TRUE);
  908. - }
  909. - 
  910. - static KeybdCtrl *pKbdCtrl = (KeybdCtrl *) 0;
  911. - 
  912. - /*ARGSUSED*/
  913.   void
  914. ! sunBlockHandler(nscreen, pbdata, pptv, pReadmask)
  915. !     int nscreen;
  916. !     pointer pbdata;
  917. !     struct timeval **pptv;
  918. !     pointer pReadmask;
  919.   {
  920. !     static struct timeval artv = { 0, 0 };    /* autorepeat timeval */
  921. ! 
  922. !     if (!autoRepeatKeyDown)
  923.       return;
  924. ! 
  925. !     if (pKbdCtrl == (KeybdCtrl *) 0)
  926. !     pKbdCtrl = ((KbPrivPtr) LookupKeyboardDevice()->devicePrivate)->ctrl;
  927. ! 
  928. !     if (pKbdCtrl->autoRepeat != AutoRepeatModeOn)
  929.       return;
  930. ! 
  931. !     if (autoRepeatFirst == TRUE)
  932. !     artv.tv_usec = autoRepeatInitiate;
  933. !     else
  934. !     artv.tv_usec = autoRepeatDelay;
  935. !     *pptv = &artv;
  936. ! 
  937. !     if (autoRepeatDebug)
  938. !     ErrorF("sunBlockHandler(%d,%d): \n", artv.tv_sec, artv.tv_usec);
  939.   }
  940. ! 
  941. ! /*ARGSUSED*/
  942.   void
  943. ! sunWakeupHandler(nscreen, pbdata, err, pReadmask)
  944. !     int nscreen;
  945. !     pointer pbdata;
  946. !     unsigned long err;
  947. !     pointer pReadmask;
  948. ! {
  949. !     struct timeval tv;
  950. ! 
  951. !     if (autoRepeatDebug)
  952. !     ErrorF("sunWakeupHandler(ar=%d, err=%d):\n", autoRepeatKeyDown, err);
  953. ! 
  954. !     if (pKbdCtrl == (KeybdCtrl *) 0)
  955. !     pKbdCtrl = ((KbPrivPtr) LookupKeyboardDevice()->devicePrivate)->ctrl;
  956. ! 
  957. !     if (pKbdCtrl->autoRepeat != AutoRepeatModeOn)
  958. !     return;
  959.   
  960. !     if (autoRepeatKeyDown) {
  961. !     gettimeofday(&tv, (struct timezone *) NULL);
  962. !     tvminus(autoRepeatDeltaTv, tv, autoRepeatLastKeyDownTv);
  963. !     if (autoRepeatDeltaTv.tv_sec > 0 ||
  964. !             (!autoRepeatFirst && autoRepeatDeltaTv.tv_usec >
  965. !                 autoRepeatDelay) ||
  966. !             (autoRepeatDeltaTv.tv_usec >
  967. !                 autoRepeatInitiate))
  968. !         autoRepeatReady++;
  969. !     }
  970.       
  971. !     if (autoRepeatReady)
  972.       ProcessInputEvents();
  973. !     autoRepeatReady = 0;
  974.   }
  975. --- 429,533 ----
  976.   
  977.   /*-
  978.    *-----------------------------------------------------------------------
  979. !  * LegalModifier --
  980. !  *    See if a key is legal as a modifier. We're very lenient around,
  981. !  *    here, so we always return true.
  982.    *
  983.    * Results:
  984. !  *    TRUE.
  985.    *
  986.    * Side Effects:
  987. +  *    None.
  988.    *
  989.    *-----------------------------------------------------------------------
  990.    */
  991.   Bool
  992. ! LegalModifier(key)
  993.   {
  994.       return (TRUE);
  995.   }
  996.   
  997. ! static KeybdCtrl *pKbdCtrl = (KeybdCtrl *) 0;
  998.   
  999.   /*-
  1000.    *-----------------------------------------------------------------------
  1001. !  * sunBlockHandler --
  1002. !  *    Tell the OS layer when to timeout to implement auto-repeat.
  1003. !  *
  1004.    * Results:
  1005. +  *    None.
  1006.    *
  1007.    * Side Effects:
  1008. +  *    The timeout value may be overwritten.
  1009.    *
  1010.    *-----------------------------------------------------------------------
  1011.    */
  1012.   void
  1013. ! sunBlockHandler (index, pKeyboard, ppTime, pReadMask)
  1014. !     int                index;        /* Screen index */
  1015. !     DevicePtr        pKeyboard;    /* Keyboard for which to do auto-repeat */
  1016. !     struct timeval  **ppTime;     /* Pointer to timeout to use */
  1017. !     int                *pReadMask;    /* Mask the OS Layer will use for select. */
  1018.   {
  1019. !     if (repeatPhase == REPEAT_LONG) {
  1020. !     /*
  1021. !      * Beginning long timeout
  1022. !      */
  1023. !     repeatDelta = repeatLong;
  1024. !     } else if (repeatPhase == REPEAT_SHORT) {
  1025. !     /*
  1026. !      * Beginning short timeout
  1027. !      */
  1028. !     repeatDelta = repeatShort;
  1029. !     } else if (repeatPhase == REPEAT_NONE) {
  1030. !     /*
  1031. !      * No repeat necessary -- it can block as long as it wants to
  1032. !      */
  1033.       return;
  1034. !     } else if (repeatPhase == REPEAT_TIMEOUT) {
  1035. !     /*
  1036. !      * Interrupted timeout -- use old timeout (that was modified by
  1037. !      * select in the OS layer)
  1038. !      */
  1039. !     *ppTime = &repeatTimeout;
  1040.       return;
  1041. !     }
  1042. !     repeatTimeout.tv_sec = repeatDelta / 1000;
  1043. !     repeatTimeout.tv_usec = repeatDelta * 1000;
  1044. !     repeatPhase = REPEAT_TIMEOUT;
  1045. !     *ppTime = &repeatTimeout;
  1046.   }
  1047. ! 
  1048. ! /*-
  1049. !  *-----------------------------------------------------------------------
  1050. !  * sunWakeupHandler --
  1051. !  *    Figure out if should do a repeat when the server wakes up. Because
  1052. !  *    select will modify repeatTimeout to contain the time left, we
  1053. !  *    can tell if the thing timed out.
  1054. !  *
  1055. !  * Results:
  1056. !  *    None.
  1057. !  *
  1058. !  * Side Effects:
  1059. !  *    repeatPhase may be changed to REPEAT_PENDING. If it is, *pNumReady
  1060. !  *    will be set to 1 and the keyboard's stream marked ready in the
  1061. !  *    result mask.
  1062. !  *
  1063. !  *-----------------------------------------------------------------------
  1064. !  */
  1065.   void
  1066. ! sunWakeupHandler (index, pKeyboard, pNumReady, pReadMask)
  1067. !     int              index;        /* Screen index */
  1068. !     DevicePtr      pKeyboard;    /* Keyboard to repeat */
  1069. !     int              *pNumReady;     /* Pointer to number of ready streams */
  1070. !     int              *pReadMask;    /* Ready streams */
  1071. ! {
  1072. !     KbPrivPtr      pPriv;
  1073.   
  1074. !     pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
  1075.       
  1076. !     if ((repeatPhase == REPEAT_TIMEOUT) && (pNumReady == 0)) {
  1077. !     repeatPhase = REPEAT_PENDING;
  1078.       ProcessInputEvents();
  1079. !     }
  1080.   }
  1081.